package com.ghsc.ghxc.jsb.utils;

import android.content.Context;
import android.content.res.AssetManager;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonNull;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;

import org.json.JSONArray;
import org.json.JSONObject;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * JSON解析二次封装
 */
public class JsonUtils {
    // 采取单例模式
    private static Gson gson = new Gson();

    private JsonUtils() {
    }

    /**
     * @param src :将要被转化的对象
     * @return :转化后的JSON串
     * @MethodName : toJson
     * @Description : 将对象转为JSON串，此方法能够满足大部分需求
     */
    public static String toJson(Object src) {
        if (null == src) {
            return gson.toJson(JsonNull.INSTANCE);
        }
        try {
            return gson.toJson(src);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @param json
     * @param classOfT
     * @return
     * @MethodName : fromJson
     * @Description : 用来将JSON串转为对象，但此方法不可用来转带泛型的集合
     */
    public static <T> Object fromJson(String json, Class<T> classOfT) {
        try {
            return gson.fromJson(json, (Type) classOfT);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @param json
     * @param typeOfT
     * @return
     * @MethodName : fromJson
     * @Description : 用来将JSON串转为对象，此方法可用来转带泛型的集合，如：Type为 new
     * TypeToken<List<T>>(){}.getType()
     * ，其它类也可以用此方法调用，就是将List<T>替换为你想要转成的类
     */
    public static Object fromJson(String json, Type typeOfT) {
        try {
            return gson.fromJson(json, typeOfT);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取json中的某个值
     *
     * @param json
     * @param key
     * @return
     */
    public static String getValue(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optString(key);
        } catch (Exception e) {
//            e.printStackTrace();
            return "";
        }
    }

    public static Long getLongValue(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optLong(key);
        } catch (Exception e) {
//            e.printStackTrace();
            return 0L;
        }
    }

    public static JSONObject toJSONObject(Object src) {
        try {
            JSONObject object = new JSONObject(toJson(src));
            return object;
        } catch (Exception e) {
//            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取json中的某个值
     *
     * @param json
     * @param key
     * @return
     */
    public static JSONArray getArray(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.getJSONArray(key);
        } catch (Exception e) {
            return null;
        }

    }

    public static boolean getValueBoolean(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optBoolean(key, false);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取json中的list值
     *
     * @param json
     * @return
     */
    public static String getListValue(String json) {
        try {
            JSONObject object = new JSONObject(json);
            return object.getString("list");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "";
    }

    public static Double getDoubleValue(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optDouble(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static Double getDoubleValue(String json, String key, Double defuault) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optDouble(key, defuault);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return defuault;
    }


    public static Integer getIntValueNull(String json, String key) {
        try {
            JSONObject object = new JSONObject(json);
            return object.optInt(key, -1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    public static String getJson(Context context, String fileName) {
        StringBuilder stringBuilder = new StringBuilder();
        try {
            AssetManager assetManager = context.getAssets();
            BufferedReader bf = new BufferedReader(new InputStreamReader(
                    assetManager.open(fileName)));
            String line;
            while ((line = bf.readLine()) != null) {
                stringBuilder.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return stringBuilder.toString();
    }




    /**
     * 在所有关于 数据库操作之后，1，强制下载，2，全部下载
     * ==以上两种情况，在完全写完数据库之后，在做所有 检查本地 order 是否 voided 的 操作
     */
   /* public static void finalCheckOrderIsVoided() {
        List<axOrder> axOrderList = DBHelper.axOrderByVoided();

        if (!axOrderList.isEmpty()) {
            for (axOrder axOrder : axOrderList) {
                //=== 是否所有AxOrderTransaction void了
                List<axOrderTransaction> orderTransactionList = DBHelper.queryAxOrderTransactionByOrderIDForSyncTask(axOrder.getAxOrderID());

                //=== 是否所有payment voided了
                List<axPayment> paymentList = DBHelper.axPaymentByOrderIdForAyncTask(axOrder.getAxOrderID());

                //=== OrderTransaction 不是全部void的，或者 payment 不是全部voided；  order就要改成open状态  否则是 voided 状态
                if (orderTransactionList.size() > 0 || paymentList.size() > 0) {
                    axOrder.setOrderStatus(1);//open
                    //更新数据库
                    DBHelper.addOrUpdate(axOrder.class, axOrder);
                    //todo:调用计算的方法  OrderCalculate().recalculateAndSave(orderID: orderID)
                }


            }

            *//*  SQL 语句-->
                select distinct axOrder.axOrderID from axOrder inner join axOrderTransaction on axOrder.axOrderID = axOrderTransaction.axOrderID where axOrder.RecDeleted = 0 and axOrderTransaction.RowTS is null
                union
                select distinct axOrder.axOrderID from axOrder inner join axPayment on axOrder.axOrderID = axPayment.axOrderID where axOrder.RecDeleted = 0 and  axPayment.RowTS is NULL
            *//*
            //先找axOrder表中axOrder.RecDeleted==0 的集合，然后找出所有axOrderID
            List<axOrder> orderList = DBHelper.queryListForSyncTask(axOrder.class, false, axOrder_.RecDeleted);



        }


    }*/

    /**
     * 转成list
     * 解决泛型问题
     *
     * @param json
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> List<T> jsonToList(String json, Class<T> cls) {
        //异常处理
        try {
            if (json.equals("[]")) {
                return null;
            }
//            Gson gson = new Gson();
            List<T> list = new ArrayList<T>();
            JsonArray array = new JsonParser().parse(json).getAsJsonArray();
            for (JsonElement elem : array) {
                list.add(gson.fromJson(elem, cls));
            }
            return list;
        } catch (Exception e) {
            return null;
        }
    }


    /**
     * 将Map转成json
     *
     * @param map
     * @return
     */
    public static String mapToJson(Map<String, Object> map) {
        Gson gson = new Gson();
        return gson.toJson(map, Map.class);
    }

    /**
     * 将Map转成json
     *
     * @param map
     * @return
     */
    public static String mapToIntJson(Map<String, Integer> map) {
        Gson gson = new Gson();
        return gson.toJson(map, Map.class);
    }

    /**
     * 依据json字符串返回Map对象
     *
     * @param json
     * @return
     */
    public static HashMap<String, Object> toMap(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, HashMap.class);
    }



    /**
     * 依据json字符串返回Map对象
     *
     * @param json
     * @return
     */
    public static <T> T toMap(String json, Class<T> classOfT) {
        Gson gson = new Gson();
        return gson.fromJson(json, classOfT);
    }



    /**
     * 对需要保存的bean类字段为null的处理
     *
     * @param src :将要被转化的对象
     * @return :转化后的JSON串
     * @MethodName : toJson
     * @Description : 将对象转为JSON串，此方法能够满足大部分需求
     */
    public static String toJsonNull(Object src) {
        if (null == src) {
            return create().toJson(JsonNull.INSTANCE);
        }
        try {
            return create().toJson(src);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }

    private static Gson create() {
        return new GsonBuilder()
                .serializeNulls()
                .create();
    }

    /**
     * 获取利用反射获取类里面的值和名称
     *
     * @param obj
     * @return
     * @throws IllegalAccessException
     */
    public static Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
        Map<String, Object> map = new HashMap<>();
        Class<?> clazz = obj.getClass();
        for (Field field : clazz.getDeclaredFields()) {
            field.setAccessible(true);
            String fieldName = field.getName();
            Object value = field.get(obj);
            map.put(fieldName, value);
        }
        return map;
    }


}

